package com.bkgy.util;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class CalUtils {

    public static void main(String[] args) {
        // 创建一个示例列表
        List<Double> list = new ArrayList<>();
        for (double i = 1.0; i <= 15.0; i++) {
            list.add(i);
        }

        // 打印原始列表
        System.out.println("Original list: " + list);

        // 截取头部5条数据和尾部5条数据
        int startIndex = 5; // 头部5条数据的起始索引
        int endIndex = list.size() - 5; // 尾部5条数据的结束索引（不包括）

        // 获取中间的子列表（不包括头部和尾部的数据）
        List<Double> middlePart = list.subList(startIndex, endIndex);

        // 从原始列表中移除头部和尾部的数据
        list.subList(0, startIndex).clear(); // 移除头部5条数据
        list.subList(list.size() - 5, list.size()).clear(); // 移除尾部5条数据（如果之前没有这样做）

        // 现在将中间的子列表添加回原始列表（可选步骤，如果需要保持顺序）
        list.addAll(middlePart);

        // 打印处理后的列表
        System.out.println("Processed list: " + list);
    }
    //众数，出现最多的数据
    public static Double findMostFrequentNumber(List<Double> list) {
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        // 使用HashMap来计数每个数字的出现次数
        Map<Double, Integer> countMap = new HashMap<>();
        for (Double num : list) {
            countMap.put(num, countMap.getOrDefault(num, 0) + 1);
        }
        // 初始化最大计数值和对应的数字
        int maxCount = 0;
        Double mostFrequent = null;
        // 找到出现次数最多的数字
        for (Map.Entry<Double, Integer> entry : countMap.entrySet()) {
            if (entry.getValue() > maxCount) {
                maxCount = entry.getValue();
                mostFrequent = entry.getKey();
            }
        }
        return mostFrequent;
    }

    //list均值
    public Double calAvg(List<Double> list){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        return list.stream().mapToDouble(Number::doubleValue).summaryStatistics().getAverage();
    }
    //list最大值
    public Double calMax(List<Double> list){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        return list.stream().mapToDouble(Number::doubleValue).summaryStatistics().getMax();
    }
    //list最小值
    public Double calMin(List<Double> list){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        return list.stream().mapToDouble(Number::doubleValue).summaryStatistics().getMin();
    }
    //list极差
    public Double calRange(List<Double> list){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        Double max = calMax(list);
        Double min = calMin(list);
        return max - min;
    }
    //list标准差
    public Double calStandard(List<Double> list){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        Double avg = calAvg(list);
        Double dVar= 0.0;
        for (Double value : list) {
            dVar+=(value-avg)*(value-avg);
        }
        return Math.sqrt(dVar/list.size());
    }
    //list截取高速段下标
    public Map<String, Integer> calHighLowSection(List<Double> list){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        HashMap<String, Integer> map = new HashMap<>();
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i)>300){
                map.put("start",i);
                break;
            }
        }
        for (int i = list.size() - 1; i >= 0; i--) {
            if(list.get(i)>300){
                map.put("stop",i);
                break;
            }
        }
        return map;
    }
    //list根据坐标前后截取一段
    public List<Double> calSubSection(List<Double> list,Integer a,Integer b){
        if(CollectionUtils.isEmpty(list)||a==null||b==null){
            return null;
        }
        return list.subList(a,b);
    }
    //list根据坐标截取头部一段
    public List<Double> calSubHead(List<Double> list,Integer a){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        return list.subList(0,a);
    }
    //list根据坐标截取中部一段
    public List<Double> calSubMid(List<Double> list,Integer a,Integer b){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        return list.subList(a,list.size() - b);
    }
    //list根据坐标截取尾部一段
    public List<Double> calSubTail(List<Double> list,Integer a){
        if(CollectionUtils.isEmpty(list)){
            return null;
        }
        return list.subList(list.size() - a,list.size());
    }
    //list处理blob数据
    public List<Double> analysisBlobData(byte[] blob){
        String data = new String(blob);
        if(!StringUtils.hasText(data)){
            return null;
        }
        return Arrays.stream(data.split(",")).map(Double::parseDouble).collect(Collectors.toList());
    }
    //list两个List对应下标相减(两个list长度需一致)
    public List<Double> calListReduce(List<Double> list1,List<Double> list2){
        if (list1 != null && list2 != null) {
            if(list1.size()!=list2.size()){
                return null;
            }
            LinkedList<Double> list = new LinkedList<>();
            for (int i = 0; i < list1.size(); i++) {
                list.add(Math.abs(list1.get(i)-list2.get(i)));
            }
            return list;
        } else {
            return null;
        }
    }
    //处理带时区时间的相差8小时
    public String calDateTime(String time){
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime dateTime = LocalDateTime.parse(time, pattern);
        LocalDateTime dateTime1 = dateTime.minusHours(8);
        String s = dateTime1.toString();
        if(StringUtils.hasText(s)){
            s+=".000+00:00";
        }
        return s;
    }
}
